package com.utils.dateUtil;

import java.beans.PropertyEditorSupport;
import java.sql.Timestamp;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;

/**
 * 
 * 类名称：	DateUtil  
 * 类描述：	时间操作工具类
 * 创建时间：	2016-8-9 下午5:21:51  
 * @version 1.0.0
 */
public class DateUtil extends PropertyEditorSupport {
	// 各种时间格式
	public static final SimpleDateFormat date_sdf = new SimpleDateFormat("yyyy-MM-dd");
	// 各种时间格式
	public static final SimpleDateFormat yyyyMMdd = new SimpleDateFormat("yyyyMMdd");
	// 各种时间格式
	public static final SimpleDateFormat date_sdf_wz = new SimpleDateFormat("yyyy年MM月dd日");
	public static final SimpleDateFormat time_sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm");
	public static final SimpleDateFormat yyyymmddhhmmss = new SimpleDateFormat("yyyyMMddHHmmss");
	public static final SimpleDateFormat short_time_sdf = new SimpleDateFormat("HH:mm");
	public static final  SimpleDateFormat datetimeFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
	public static final SimpleDateFormat yymmddhhmmss = new SimpleDateFormat("yyMMddHHmmss");
	//返回日期
	public static final SimpleDateFormat dd = new SimpleDateFormat("dd");
	// 以毫秒表示的时间
	private static final long DAY_IN_MILLIS = 24 * 3600 * 1000;
	private static final long HOUR_IN_MILLIS = 3600 * 1000;
	private static final long MINUTE_IN_MILLIS = 60 * 1000;
	private static final long SECOND_IN_MILLIS = 1000;

	/**
	 * 
	 * getSDFormat( 指定模式的时间格式)  
	 * @param pattern   指定的格式
	 * @return  SimpleDateFormat   时间格式
	 * @since  1.0.0
	 */
	private static SimpleDateFormat getSDFormat(String pattern) {
		return new SimpleDateFormat(pattern);
	}

	/**
	 * 
	 * getDate(获取系统当前日期)  
	 * @return  Date       系统当前时间
	 * @since  1.0.0
	 */
	public static Date getDate() {
		return new Date();
	}
	/**
	 * 
	 * getCurrentTime(获取"yyyy-MM-dd HH:mm:ss"格式化后的系统当前时间)  
	 * @return  String   系统当前时间
	 * @since  1.0.0
	 */
	public static String getCurrentTime() {
		java.util.Date date = new java.util.Date();
		SimpleDateFormat s = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		return s.format(date);
	}

	/**
	 * 
	 * date2Str(把指定日期转换为指定格式的字符串)  
	 * @param date          日期
	 * @param date_sdf      时间格式
	 * @return  String      格式化后的时间字符串
	 * @since  1.0.0
	 */
	public static String dateToString(Date date) {
		if (null == date) {
			return null;
		}
		return date_sdf.format(date);
	}

	/**
	 * 
	 * getTimestamp(获取系统当前的时间戳)  
	 * @return  Timestamp      系统当前的时间戳
	 * @since  1.0.0
	 */
	public static Timestamp getTimestamp() {
		return new Timestamp(new Date().getTime());
	}
	
	/**
	 * 
	 * Date(日期格式化)  
	 * @return  Date     
	 * @since  1.0.0
	 */
	
	public static Date day(Date date) {
			SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
			try {
				return dateFormat.parse(dateFormat.format(date));
			} catch (ParseException e) {
				e.printStackTrace();
			}
			return date;
	}
	
	/**
	 * 
	 * datePeriod(获取系统当前的时间戳)  
	 * @return  long     用于计算Date类型相差的天数
	 * @since  1.0.0
	 */
	public static long datePeriod(Date start,Date end){
		Date startDay = day(start);
		Date endDay = day(end);
		if (startDay == null || endDay == null) {
			return -1;
		}
		return Math.abs((startDay.getTime() - endDay.getTime()) / (1000L * 60L * 60L * 24L));
	}
	
	
	
	/**
	 * 
	 * getMillis(获取指定日历的毫秒数) 
	 * 后面计算时间差会用到 
	 * @param cal       指定日历
	 * @return  long    指定日历的毫秒数   
	 * @since  1.0.0
	 */
	public static long getMillis(Calendar cal) {
		return cal.getTime().getTime();
	}

	/**
	 * 
	 * formatDate(默认方式为date_sdf的系统当前日期，具体格式：年-月-日)  
	 * @return  String   默认日期按“年-月-日“格式显示的时间字符串
	 * @since  1.0.0
	 */
	public static String formatDate() {
		return date_sdf.format(getDate().getTime());
	}

	/**
	 * 
	 * getDateString(按指定的时间格式获取时间字符串)  
	 * @param formatstr      时间格式,例如:date_sdf_wz   
	 * @return  String       格式化后的时间字符串
	 * @since  1.0.0
	 */
	public static String getDateString(SimpleDateFormat formatstr) {
		return formatstr.format(getDate().getTime());
	}

	/**
	 * 
	 * formatDate(默认日期按指定格式显示)  
	 * @param pattern     指定的格式      例如:"yyyy/MM/dd"
	 * @return  String    默认日期按指定格式显示   
	 * @since  1.0.0
	 */
	public static String formatDate(String pattern) {
		return getSDFormat(pattern).format(getDate().getTime());
	}

	/**
	 * 
	 * dateDiff(计算两个时间之间的差值，根据标志的不同而不同)  
	 * @param flag       计算标志，表示按照年/月/日/时/分/秒等计算
	 * @param calSrc     减数
	 * @param calDes     被减数
	 * @return  int      两个日期之间的差值   
	 * @since  1.0.0
	 */
	@SuppressWarnings("static-access")
	public static int dateDiff(char flag, Calendar calSrc, Calendar calDes) {

		long millisDiff = getMillis(calSrc) - getMillis(calDes);

		if (flag == 'y') {
			return (calSrc.get(calSrc.YEAR) - calDes.get(calDes.YEAR));
		}

		if (flag == 'd') {
			return (int) (millisDiff / DAY_IN_MILLIS);
		}

		if (flag == 'h') {
			return (int) (millisDiff / HOUR_IN_MILLIS);
		}

		if (flag == 'm') {
			return (int) (millisDiff / MINUTE_IN_MILLIS);
		}

		if (flag == 's') {
			return (int) (millisDiff / SECOND_IN_MILLIS);
		}

		return 0;
	}

	/**
	 * 根据指定的格式将字符串转换成Date 如输入：2003-11-19 11:20:20将按照这个转成时间
	 * 
	 * @param src
	 *            将要转换的原始字符窜
	 * @param pattern
	 *            转换的匹配格式
	 * @return 如果转换成功则返回转换后的日期
	 * @throws ParseException
	 * @throws AIDateFormatException
	 */
	public static Date parseDate(String src, String pattern)
			throws ParseException {
		return getSDFormat(pattern).parse(src);

	}
	/**
	 * 
	 * nowtime(获取当前年份)  
	 * 
	 * @return  String   
	 * @exception (标注Runtime异常)
	 * @throws (标注非Runtime异常)
	 * @since  1.0.0
	 */
	public static String nowtime(){
		Calendar calendar = Calendar.getInstance();
		SimpleDateFormat formatter = new SimpleDateFormat("yyyy");
		String nowtime=formatter.format(calendar.getTime());
		return nowtime;
	}

	/**
	 * 
	 * beforetime(获取当前年份n年之前年份)  
	 * @param year
	 * @return  String   
	 * @exception (标注Runtime异常)
	 * @throws (标注非Runtime异常)
	 * @since  1.0.0
	 */
	public static String beforetime(int year){
		Calendar calendar = Calendar.getInstance();
		calendar.add(Calendar.YEAR, -year);
		SimpleDateFormat formatter = new SimpleDateFormat("yyyy");
		String beforetime=formatter.format(calendar.getTime());
		return beforetime;
	}

	/**
	 * 
	 * getCurrentYear(获取当前系统年份)  
	 * (这里描述这个方法适用条件 – 可选)  
	 * @return  String   
	 * @exception    
	 * @since  1.0.0
	 */
	public static String getCurrentYear() {
		String result     = "";
		Calendar calendar = Calendar.getInstance();
		int year          = calendar.get(Calendar.YEAR);
		result = year > 0 ? String.valueOf(year) : "";
		return result;
	}
	/**
	 * 
	 * getCurrentMonth(获取当前系统月份)  
	 * (这里描述这个方法适用条件 – 可选)  
	 * @return  String   
	 * @exception    
	 * @since  1.0.0
	 */
	public static String getCurrentMonth() {
		Calendar calendar = Calendar.getInstance();
		int month          = calendar.get(Calendar.MONTH)+1;
		if(month>10){
			return String.valueOf(month);
		}else if (month>0 && month<10){
			return "0"+String.valueOf(month);
		}else{
			return "";
		}
	}

	/**
	 * 
	 * getFlagDate(判断字符串是否能转换为时间)  
	 * @param string
	 * @return  boolean   
	 * @exception  
	 * @since  1.0.0
	 * @name lihr 2016-02-22
	 */
	public static boolean getFlagDate(String date){
		try{
			date_sdf.parse(date);
		}catch(Exception ex){
			return false;
		}
		return true;
	}

	/**
	 * 
	 * getStringtoString(转换时间字符串格式)  
	 * @param str
	 * @return  String   
	 * @exception    
	 * @since  1.0.0
	 * @name lihr 2016-02-22
	 */
	public static String getStringtoString(String str,int type){
		String sDateTime="";
		try {
			Date date = null;
			if(type==1) {
				date=date_sdf.parse(str);
				sDateTime = yyyyMMdd.format(date);
			}else if(type==2) {
				date=date_sdf.parse(str);
				sDateTime = dd.format(date);
			}else {
				date=datetimeFormat.parse(str);
				sDateTime = datetimeFormat.format(date);
			}
		} catch (Exception e) {
			return null;
		}
		return sDateTime;
	}

	/**
	 * 返回yyyy-MM-dd HH:mm:ss格式时间
	 * @return
	 */
	public static String getNewDate(){
		return datetimeFormat.format(new Date());
	}
	/**
	 * 获取两个日期相差月份，大于15天，按一个月计算
	 * @param beginDate
	 * @param endDate
	 * @return
	 */
	public static int getMonthNum(Date beginDate, Date endDate){
		
			int result=0;
			//获取开始日期的年月日
			Calendar c1 = Calendar.getInstance();
			 c1.setTime(beginDate);
		    int startYear = c1.get(Calendar.YEAR);
		    int startMonth = c1.get(Calendar.MONTH);
		    int startDay = c1.get(Calendar.DAY_OF_MONTH);
		  
		    //获取结束日期的年月 日
		    Calendar c2 = Calendar.getInstance();
		    c2.setTime(endDate);
		    int endYear = c2.get(Calendar.YEAR);
		    int endMonth = c2.get(Calendar.MONTH);
		    int endDay = c2.get(Calendar.DAY_OF_MONTH);
		    
		    //获取两日期相差天数
		    int days=endDay-startDay;
		   
		    //如果开始结束日期的年份相同，则计算相差月份
		    if(startYear==endYear){
		    	result=endMonth-startMonth;//两个日期相差几个月，即月份差
			   if(days>=15){
				   result ++; 
			   }
		    }else{
		    	result=12*(endYear-startYear)+endMonth-startMonth; 
				if(days>=15){
					result ++; 
				 }
		    }
		 
		return result;
	}
	
	public static void main(String[] args) {
		System.out.println(getDateString(yymmddhhmmss));
		System.out.println(getYesterday("yyyyMMdd"));
		
		
//		datetimeFormat
	}
	
	
	/**
	 * 
	 * date2Str(把指定日期转换为指定格式的字符串)  
	 * @param date          日期
	 * @param date_sdf      时间格式
	 * @return  String      格式化后的时间字符串
	 * @since  1.0.0
	 */
	public static String dateToString1(Date date) {
		if (null == date) {
			return null;
		}
		return datetimeFormat.format(date);
	}
	/**
	 * 根据传入的格式，获取昨天的日期
	 * @return
	 */
	public static String getYesterday(String fmd){
		Calendar   cal   =   Calendar.getInstance();
		  cal.add(Calendar.DATE,   -1);
		  String yesterday = new SimpleDateFormat(fmd).format(cal.getTime());
		  return yesterday;
	}
	
	 /** 
	    * 获取未来 第 past 天的日期 
	    * @param past 
	    * @return 
	    */  
	   public static String getFetureDate(int past) {  
	       Calendar calendar = Calendar.getInstance();  
	       calendar.set(Calendar.DAY_OF_YEAR, calendar.get(Calendar.DAY_OF_YEAR) + past);  
	       Date today = calendar.getTime();  
	       SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");  
	       String result = format.format(today);  
	       return result;  
	   }
	   
	   /** 
	     * 获得指定日期的前、后N天 
	     * @param specifiedDay 指定日期 
	     * @return  
	     */  
	   public static String getDate(String specifiedDay, int diffDays) {  
	        Calendar c = Calendar.getInstance();  
	        try {  
	            c.setTime(date_sdf.parse(specifiedDay));  
	            c.set(Calendar.DATE, c.get(Calendar.DATE) + diffDays);  
	            return date_sdf.format(c.getTime());  
	        } catch (ParseException e) {  
	            e.printStackTrace();  
	            return null;  
	        }  
	    }  
}